home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / gas_251.zip / bin_251 / binutils / ar.c < prev    next >
C/C++ Source or Header  |  1994-09-15  |  26KB  |  1,144 lines
  1. /* ar.c - Archive modify and extract.
  2.    Copyright 1991, 92, 93, 94 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU Binutils.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. /*
  21.    Bugs: should use getopt the way tar does (complete w/optional -) and
  22.    should have long options too. GNU ar used to check file against filesystem
  23.    in quick_update and replace operations (would check mtime). Doesn't warn
  24.    when name truncated. No way to specify pos_end. Error messages should be
  25.    more consistant.
  26. */
  27. #include "bfd.h"
  28. #include "sysdep.h"
  29. #include "libiberty.h"
  30. #include "bucomm.h"
  31. #include "aout/ar.h"
  32. #include "libbfd.h"
  33. #include "arsup.h"
  34. #include <stdio.h>
  35. #ifdef POSIX_UTIME
  36. #include <utime.h>
  37. #else /* ! POSIX_UTIME */
  38. #ifdef    USE_UTIME
  39. #include <time.h>
  40. #else /* ! USE_UTIME */
  41. #include <sys/time.h>
  42. #endif /* ! USE_UTIME */
  43. #endif /* ! POSIX_UTIME */
  44. #include <errno.h>
  45. #ifndef errno
  46. extern int errno;
  47. #endif
  48. #define BUFSIZE 8192
  49.  
  50. #ifdef __GO32___
  51. #define EXT_NAME_LEN 3        /* bufflen of addition to name if it's MS-DOS */
  52. #else
  53. #define EXT_NAME_LEN 6        /* ditto for *NIX */
  54. #endif
  55.  
  56. /* Kludge declaration from BFD!  This is ugly!  FIXME!  XXX */
  57.  
  58. struct ar_hdr *
  59.   bfd_special_undocumented_glue PARAMS ((bfd * abfd, char *filename));
  60.  
  61. /* Forward declarations */
  62.  
  63. static void
  64. remove_output PARAMS ((void));
  65.  
  66. static void
  67. map_over_members PARAMS ((bfd *, void (*)(bfd *), char **, int));
  68.  
  69. static void
  70. print_contents PARAMS ((bfd * member));
  71.  
  72. static void
  73. delete_members PARAMS ((bfd *, char **files_to_delete));
  74.  
  75. static void
  76. do_quick_append PARAMS ((const char *archive_filename,
  77.              char **files_to_append));
  78.  
  79. static void
  80. move_members PARAMS ((bfd *, char **files_to_move));
  81.  
  82. static void
  83. replace_members PARAMS ((bfd *, char **files_to_replace));
  84.  
  85. static void
  86. print_descr PARAMS ((bfd * abfd));
  87.  
  88. static void
  89. write_archive PARAMS ((bfd *));
  90.  
  91. static void
  92. ranlib_only PARAMS ((const char *archname));
  93.  
  94. static void
  95. ranlib_touch PARAMS ((const char *archname));
  96.  
  97. /** Globals and flags */
  98.  
  99. int mri_mode;
  100.  
  101. /* This flag distinguishes between ar and ranlib:
  102.    1 means this is 'ranlib'; 0 means this is 'ar'.
  103.    -1 means if we should use argv[0] to decide.  */
  104. extern int is_ranlib;
  105.  
  106. /* Nonzero means don't warn about creating the archive file if necessary.  */
  107. int silent_create = 0;
  108.  
  109. /* Nonzero means describe each action performed.  */
  110. int verbose = 0;
  111.  
  112. /* Nonzero means preserve dates of members when extracting them.  */
  113. int preserve_dates = 0;
  114.  
  115. /* Nonzero means don't replace existing members whose dates are more recent
  116.    than the corresponding files.  */
  117. int newer_only = 0;
  118.  
  119. /* Controls the writing of an archive symbol table (in BSD: a __.SYMDEF
  120.    member).  -1 means we've been explicitly asked to not write a symbol table;
  121.    +1 means we've been explictly asked to write it;
  122.    0 is the default.
  123.    Traditionally, the default in BSD has been to not write the table.
  124.    However, for POSIX.2 compliance the default is now to write a symbol table
  125.    if any of the members are object files.  */
  126. int write_armap = 0;
  127.  
  128. /* Nonzero means it's the name of an existing member; position new or moved
  129.    files with respect to this one.  */
  130. char *posname = NULL;
  131.  
  132. /* Sez how to use `posname': pos_before means position before that member.
  133.    pos_after means position after that member. pos_end means always at end.
  134.    pos_default means default appropriately. For the latter two, `posname'
  135.    should also be zero.  */
  136. enum pos
  137.   {
  138.     pos_default, pos_before, pos_after, pos_end
  139.   } postype = pos_default;
  140.  
  141. int interactive = 0;
  142.  
  143. void
  144. mri_emul ()
  145. {
  146.   interactive = isatty (fileno (stdin));
  147.   yyparse ();
  148. }
  149.  
  150. /* If COUNT is 0, then FUNCTION is called once on each entry.  If nonzero,
  151.    COUNT is the length of the FILES chain; FUNCTION is called on each entry
  152.    whose name matches one in FILES.  */
  153.  
  154. static void
  155. map_over_members (arch, function, files, count)
  156.      bfd *arch;
  157.      void (*function) PARAMS ((bfd *));
  158.      char **files;
  159.      int count;
  160. {
  161.   bfd *head;
  162.  
  163.   if (count == 0)
  164.     {
  165.       for (head = arch->next; head; head = head->next)
  166.     function (head);
  167.       return;
  168.     }
  169.   /* This may appear to be a baroque way of accomplishing what we want.
  170.      However we have to iterate over the filenames in order to notice where
  171.      a filename is requested but does not exist in the archive.  Ditto
  172.      mapping over each file each time -- we want to hack multiple
  173.      references.  */
  174.  
  175.   for (; count > 0; files++, count--)
  176.     {
  177.       boolean found = false;
  178.       for (head = arch->next; head; head = head->next)
  179.     {
  180.       if (head->filename == NULL)
  181.         {
  182.           /* Some archive formats don't get the filenames filled in
  183.          until the elements are opened.  */
  184.           struct stat buf;
  185.           bfd_stat_arch_elt (head, &buf);
  186.         }
  187.       if ((head->filename != NULL) &&
  188.           (!strcmp (*files, head->filename)))
  189.         {
  190.           found = true;
  191.           function (head);
  192.         }
  193.     }
  194.       if (!found)
  195.     fprintf (stderr, "no entry %s in archive\n", *files);
  196.     }
  197. }
  198.  
  199. boolean operation_alters_arch = false;
  200.  
  201. extern char *program_version;
  202.  
  203. void
  204. do_show_version ()
  205. {
  206.   printf ("GNU %s version %s\n", program_name, program_version);
  207.   xexit (0);
  208. }
  209.  
  210. void
  211. usage ()
  212. {
  213.   if (is_ranlib == 0)
  214.     fprintf (stderr, "\
  215. Usage: %s [-]{dmpqrtx}[abcilosuvV] [member-name] archive-file file...\n\
  216.        %s -M [<mri-script]\n",
  217.          program_name, program_name);
  218.   else
  219.     fprintf (stderr, "\
  220. Usage: %s [-vV] archive\n", program_name);
  221.   xexit (1);
  222. }
  223.  
  224. /* Remove any output file.  This is only called via xatexit.  */
  225.  
  226. static char *output_filename = NULL;
  227. static FILE *output_file = NULL;
  228. static bfd *output_bfd = NULL;
  229.  
  230. static void
  231. remove_output ()
  232. {
  233.   if (output_filename != NULL)
  234.     {
  235.       if (output_bfd != NULL && output_bfd->iostream != NULL)
  236.     fclose ((FILE *) (output_bfd->iostream));
  237.       if (output_file != NULL)
  238.     fclose (output_file);
  239.       unlink (output_filename);
  240.     }
  241. }
  242.  
  243. /* The option parsing should be in its own function.
  244.    It will be when I have getopt working.  */
  245.  
  246. int
  247. main (argc, argv)
  248.      int argc;
  249.      char **argv;
  250. {
  251.   char *arg_ptr;
  252.   char c;
  253.   enum
  254.     {
  255.       none = 0, delete, replace, print_table,
  256.       print_files, extract, move, quick_append
  257.     } operation = none;
  258.   int arg_index;
  259.   char **files;
  260.   char *inarch_filename;
  261.   char *temp;
  262.   int show_version;
  263.  
  264.   program_name = argv[0];
  265.   xmalloc_set_program_name (program_name);
  266.  
  267.   bfd_init ();
  268.   show_version = 0;
  269.  
  270.   xatexit (remove_output);
  271.  
  272.   temp = strrchr (program_name, '/');
  273.   if (temp == (char *) NULL)
  274.     temp = program_name;    /* shouldn't happen, but... */
  275.   else
  276.     ++temp;
  277.   if (is_ranlib > 0 || (is_ranlib < 0 && strcmp (temp, "ranlib") == 0))
  278.     {
  279.       boolean touch = false;
  280.  
  281.       is_ranlib = 1;
  282.       if (argc < 2)
  283.     usage ();
  284.       if (strcmp (argv[1], "-V") == 0
  285.       || strcmp (argv[1], "-v") == 0
  286.       || strncmp (argv[1], "--v", 3) == 0)
  287.     do_show_version ();
  288.       arg_index = 1;
  289.       if (strcmp (argv[1], "-t") == 0)
  290.     {
  291.       ++arg_index;
  292.       touch = true;
  293.     }
  294.       while (arg_index < argc)
  295.     {
  296.       if (! touch)
  297.         ranlib_only (argv[arg_index]);
  298.       else
  299.         ranlib_touch (argv[arg_index]);
  300.       ++arg_index;
  301.     }
  302.       xexit (0);
  303.     }
  304.   else
  305.     is_ranlib = 0;
  306.  
  307.   if (argc == 2 && strcmp (argv[1], "-M") == 0)
  308.     {
  309.       mri_emul ();
  310.       xexit (0);
  311.     }
  312.  
  313.   if (argc < 2)
  314.     usage ();
  315.  
  316.   arg_ptr = argv[1];
  317.  
  318.   if (*arg_ptr == '-')
  319.     ++arg_ptr;            /* compatibility */
  320.  
  321.   while ((c = *arg_ptr++) != '\0')
  322.     {
  323.       switch (c)
  324.     {
  325.     case 'd':
  326.     case 'm':
  327.     case 'p':
  328.     case 'q':
  329.     case 'r':
  330.     case 't':
  331.     case 'x':
  332.       if (operation != none)
  333.         fatal ("two different operation options specified");
  334.       switch (c)
  335.         {
  336.         case 'd':
  337.           operation = delete;
  338.           operation_alters_arch = true;
  339.           break;
  340.         case 'm':
  341.           operation = move;
  342.           operation_alters_arch = true;
  343.           break;
  344.         case 'p':
  345.           operation = print_files;
  346.           break;
  347.         case 'q':
  348.           operation = quick_append;
  349.           operation_alters_arch = true;
  350.           break;
  351.         case 'r':
  352.           operation = replace;
  353.           operation_alters_arch = true;
  354.           break;
  355.         case 't':
  356.           operation = print_table;
  357.           break;
  358.         case 'x':
  359.           operation = extract;
  360.           break;
  361.         }
  362.     case 'l':
  363.       break;
  364.     case 'c':
  365.       silent_create = 1;
  366.       break;
  367.     case 'o':
  368.       preserve_dates = 1;
  369.       break;
  370.     case 'V':
  371.       show_version = true;
  372.       break;
  373.     case 's':
  374.       write_armap = 1;
  375.       break;
  376.     case 'u':
  377.       newer_only = 1;
  378.       break;
  379.     case 'v':
  380.       verbose = 1;
  381.       break;
  382.     case 'a':
  383.       postype = pos_after;
  384.       break;
  385.     case 'b':
  386.       postype = pos_before;
  387.       break;
  388.     case 'i':
  389.       postype = pos_before;
  390.       break;
  391.     case 'M':
  392.       mri_mode = 1;
  393.       break;
  394.     default:
  395.       fprintf (stderr, "%s: illegal option -- %c\n", program_name, c);
  396.       usage ();
  397.     }
  398.     }
  399.  
  400.   if (show_version)
  401.     do_show_version ();
  402.  
  403.   if (argc < 3)
  404.     usage ();
  405.  
  406.   if (mri_mode)
  407.     {
  408.       mri_emul ();
  409.     }
  410.   else
  411.     {
  412.       bfd *arch;
  413.  
  414.       if ((operation == none || operation == print_table)
  415.       && write_armap == 1)
  416.     {
  417.       ranlib_only (argv[2]);
  418.       xexit (0);
  419.     }
  420.  
  421.       if (operation == none)
  422.     fatal ("no operation specified");
  423.  
  424.       if (newer_only && operation != replace)
  425.     fatal ("`u' is only meaningful with the `r' option.");
  426.  
  427.       arg_index = 2;
  428.  
  429.       if (postype != pos_default)
  430.     posname = argv[arg_index++];
  431.  
  432.       inarch_filename = argv[arg_index++];
  433.  
  434.       files = arg_index < argc ? argv + arg_index : NULL;
  435.  
  436.       if (operation == quick_append)
  437.     {
  438.       /* Note that quick appending to a non-existent archive creates it,
  439.          even if there are no files to append. */
  440.       do_quick_append (inarch_filename, files);
  441.       xexit (0);
  442.     }
  443.  
  444.       arch = open_inarch (inarch_filename);
  445.  
  446.       switch (operation)
  447.     {
  448.     case print_table:
  449.       map_over_members (arch, print_descr, files, argc - 3);
  450.       break;
  451.  
  452.     case print_files:
  453.       map_over_members (arch, print_contents, files, argc - 3);
  454.       break;
  455.  
  456.     case extract:
  457.       map_over_members (arch, extract_file, files, argc - 3);
  458.       break;
  459.  
  460.     case delete:
  461.       if (files != NULL)
  462.         delete_members (arch, files);
  463.       break;
  464.  
  465.     case move:
  466.       if (files != NULL)
  467.         move_members (arch, files);
  468.       break;
  469.  
  470.     case replace:
  471.       if (files != NULL || write_armap > 0)
  472.         replace_members (arch, files);
  473.       break;
  474.  
  475.       /* Shouldn't happen! */
  476.     default:
  477.       fprintf (stderr, "%s: internal error -- this option not implemented\n",
  478.            program_name);
  479.       xexit (1);
  480.     }
  481.     }
  482.  
  483.   xexit (0);
  484.   return 0;
  485. }
  486.  
  487. static char *
  488. normalize (file)
  489.      char *file;
  490. {
  491.   char *filename = strrchr (file, '/');
  492.   if (filename != (char *) NULL)
  493.     {
  494.       filename++;
  495.     }
  496.   else
  497.     {
  498.       filename = file;
  499.     }
  500.   return filename;
  501. }
  502.  
  503. bfd *
  504. open_inarch (archive_filename)
  505.      const char *archive_filename;
  506. {
  507.   bfd **last_one;
  508.   bfd *next_one;
  509.   struct stat sbuf;
  510.   bfd *arch;
  511.  
  512.   bfd_set_error (bfd_error_no_error);
  513.  
  514.   if (stat (archive_filename, &sbuf) != 0)
  515.     {
  516.  
  517. #ifndef __GO32__
  518.  
  519. /* KLUDGE ALERT! Temporary fix until I figger why
  520.  * stat() is wrong ... think it's buried in GO32's IDT
  521.  * - Jax
  522.  */
  523.       if (errno != ENOENT)
  524.     bfd_fatal (archive_filename);
  525. #endif
  526.  
  527.       if (!operation_alters_arch)
  528.     {
  529.       fprintf (stderr, "%s: ", program_name);
  530.       perror (archive_filename);
  531.       maybequit ();
  532.       return NULL;
  533.     }
  534.  
  535.       /* This routine is one way to forcibly create the archive. */
  536.  
  537.       do_quick_append (archive_filename, 0);
  538.     }
  539.  
  540.   arch = bfd_openr (archive_filename, NULL);
  541.   if (arch == NULL)
  542.     {
  543.     bloser:
  544.       bfd_fatal (archive_filename);
  545.     }
  546.  
  547.   if (bfd_check_format (arch, bfd_archive) != true)
  548.     fatal ("%s is not an archive", archive_filename);
  549.   last_one = &(arch->next);
  550.   /* Read all the contents right away, regardless.  */
  551.   for (next_one = bfd_openr_next_archived_file (arch, NULL);
  552.        next_one;
  553.        next_one = bfd_openr_next_archived_file (arch, next_one))
  554.     {
  555.       *last_one = next_one;
  556.       last_one = &next_one->next;
  557.     }
  558.   *last_one = (bfd *) NULL;
  559.   if (bfd_get_error () != bfd_error_no_more_archived_files)
  560.     goto bloser;
  561.   return arch;
  562. }
  563.  
  564. static void
  565. print_contents (abfd)
  566.      bfd *abfd;
  567. {
  568.   int ncopied = 0;
  569.   struct stat buf;
  570.   long size;
  571.   if (bfd_stat_arch_elt (abfd, &buf) != 0)
  572.     fatal ("internal stat error on %s", bfd_get_filename (abfd));
  573.  
  574.   if (verbose)
  575.     printf ("\n<member %s>\n\n", bfd_get_filename (abfd));
  576.  
  577.   bfd_seek (abfd, 0, SEEK_SET);
  578.  
  579.   size = buf.st_size;
  580.   while (ncopied < size)
  581.     {
  582.       char cbuf[BUFSIZE];
  583.       int nread;
  584.       int tocopy = size - ncopied;
  585.       if (tocopy > BUFSIZE)
  586.     tocopy = BUFSIZE;
  587.  
  588.       nread = bfd_read (cbuf, 1, tocopy, abfd);    /* oops -- broke
  589.                                abstraction!  */
  590.       if (nread != tocopy)
  591.     fatal ("%s is not a valid archive",
  592.            bfd_get_filename (bfd_my_archive (abfd)));
  593.       fwrite (cbuf, 1, nread, stdout);
  594.       ncopied += tocopy;
  595.     }
  596. }
  597.  
  598. /* Extract a member of the archive into its own file.
  599.  
  600.    We defer opening the new file until after we have read a BUFSIZ chunk of the
  601.    old one, since we know we have just read the archive header for the old
  602.    one.  Since most members are shorter than BUFSIZ, this means we will read
  603.    the old header, read the old data, write a new inode for the new file, and
  604.    write the new data, and be done. This 'optimization' is what comes from
  605.    sitting next to a bare disk and hearing it every time it seeks.  -- Gnu
  606.    Gilmore  */
  607.  
  608. void
  609. extract_file (abfd)
  610.      bfd *abfd;
  611. {
  612.   FILE *ostream;
  613.   char cbuf[BUFSIZE];
  614.   int nread, tocopy;
  615.   int ncopied = 0;
  616.   long size;
  617.   struct stat buf;
  618.   if (bfd_stat_arch_elt (abfd, &buf) != 0)
  619.     fatal ("internal stat error on %s", bfd_get_filename (abfd));
  620.   size = buf.st_size;
  621.  
  622.   if (verbose)
  623.     printf ("x - %s\n", bfd_get_filename (abfd));
  624.  
  625.   bfd_seek (abfd, 0, SEEK_SET);
  626.  
  627.   ostream = 0;
  628.   if (size == 0)
  629.     {
  630.       /* Seems like an abstraction violation, eh?  Well it's OK! */
  631.       output_filename = bfd_get_filename (abfd);
  632.  
  633.       ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
  634.       if (!ostream)
  635.     {
  636.       perror (bfd_get_filename (abfd));
  637.       xexit (1);
  638.     }
  639.  
  640.       output_file = ostream;
  641.     }
  642.   else
  643.     while (ncopied < size)
  644.       {
  645.     tocopy = size - ncopied;
  646.     if (tocopy > BUFSIZE)
  647.       tocopy = BUFSIZE;
  648.  
  649.     nread = bfd_read (cbuf, 1, tocopy, abfd);
  650.     if (nread != tocopy)
  651.       fatal ("%s is not a valid archive",
  652.          bfd_get_filename (bfd_my_archive (abfd)));
  653.  
  654.     /* See comment above; this saves disk arm motion */
  655.     if (!ostream)
  656.       {
  657.         /* Seems like an abstraction violation, eh?  Well it's OK! */
  658.         output_filename = bfd_get_filename (abfd);
  659.  
  660.         ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
  661.         if (!ostream)
  662.           {
  663.         perror (bfd_get_filename (abfd));
  664.         xexit (1);
  665.           }
  666.  
  667.         output_file = ostream;
  668.       }
  669.     fwrite (cbuf, 1, nread, ostream);
  670.     ncopied += tocopy;
  671.       }
  672.  
  673.   fclose (ostream);
  674.  
  675.   output_file = NULL;
  676.   output_filename = NULL;
  677.  
  678.   chmod (bfd_get_filename (abfd), buf.st_mode);
  679.  
  680.   if (preserve_dates)
  681.     {
  682. #ifdef POSIX_UTIME
  683.       struct utimbuf tb;
  684.       tb.actime = buf.st_mtime;
  685.       tb.modtime = buf.st_mtime;
  686.       utime (bfd_get_filename (abfd), &tb);    /* FIXME check result */
  687. #else /* ! POSIX_UTIME */
  688. #ifdef USE_UTIME
  689.       long tb[2];
  690.       tb[0] = buf.st_mtime;
  691.       tb[1] = buf.st_mtime;
  692.       utime (bfd_get_filename (abfd), tb);    /* FIXME check result */
  693. #else /* ! USE_UTIME */
  694.       struct timeval tv[2];
  695.       tv[0].tv_sec = buf.st_mtime;
  696.       tv[0].tv_usec = 0;
  697.       tv[1].tv_sec = buf.st_mtime;
  698.       tv[1].tv_usec = 0;
  699.       utimes (bfd_get_filename (abfd), tv);    /* FIXME check result */
  700. #endif /* ! USE_UTIME */
  701. #endif /* ! POSIX_UTIME */
  702.     }
  703. }
  704.  
  705. /* Just do it quickly; don't worry about dups, armap, or anything like that */
  706.  
  707. static void
  708. do_quick_append (archive_filename, files_to_append)
  709.      const char *archive_filename;
  710.      char **files_to_append;
  711. {
  712.   FILE *ofile, *ifile;
  713.   char buf[BUFSIZE];
  714.   long tocopy, thistime;
  715.   bfd *temp;
  716.   struct stat sbuf;
  717.   boolean newfile = false;
  718.   bfd_set_error (bfd_error_no_error);
  719.  
  720.   if (stat (archive_filename, &sbuf) != 0)
  721.     {
  722.  
  723. #ifndef __GO32__
  724.  
  725. /* KLUDGE ALERT! Temporary fix until I figger why
  726.  * stat() is wrong ... think it's buried in GO32's IDT
  727.  * - Jax
  728.  */
  729.  
  730.       if (errno != ENOENT)
  731.     bfd_fatal (archive_filename);
  732. #endif
  733.  
  734.       newfile = true;
  735.     }
  736.  
  737.   ofile = fopen (archive_filename, FOPEN_AUB);
  738.   if (ofile == NULL)
  739.     {
  740.       perror (program_name);
  741.       xexit (1);
  742.     }
  743.  
  744.   temp = bfd_openr (archive_filename, NULL);
  745.   if (temp == NULL)
  746.     {
  747.       bfd_fatal (archive_filename);
  748.     }
  749.   if (newfile == false)
  750.     {
  751.       if (bfd_check_format (temp, bfd_archive) != true)
  752.     fatal ("%s is not an archive", archive_filename);
  753.     }
  754.   else
  755.     {
  756.       fwrite (ARMAG, 1, SARMAG, ofile);
  757.       if (!silent_create)
  758.     fprintf (stderr, "%s: creating %s\n",
  759.          program_name, archive_filename);
  760.     }
  761.  
  762.   /* assume it's an achive, go straight to the end, sans $200 */
  763.   fseek (ofile, 0, 2);
  764.  
  765.   for (; files_to_append && *files_to_append; ++files_to_append)
  766.     {
  767.       struct ar_hdr *hdr = bfd_special_undocumented_glue (temp, *files_to_append);
  768.       if (hdr == NULL)
  769.     {
  770.       bfd_fatal (*files_to_append);
  771.     }
  772.  
  773.       BFD_SEND (temp, _bfd_truncate_arname, (temp, *files_to_append, (char *) hdr));
  774.  
  775.       ifile = fopen (*files_to_append, FOPEN_RB);
  776.       if (ifile == NULL)
  777.     {
  778.       bfd_nonfatal (*files_to_append);
  779.     }
  780.  
  781.       if (stat (*files_to_append, &sbuf) != 0)
  782.     {
  783.       bfd_nonfatal (*files_to_append);
  784.     }
  785.  
  786.       tocopy = sbuf.st_size;
  787.  
  788.       /* XXX should do error-checking! */
  789.       fwrite (hdr, 1, sizeof (struct ar_hdr), ofile);
  790.  
  791.       while (tocopy > 0)
  792.     {
  793.       thistime = tocopy;
  794.       if (thistime > BUFSIZE)
  795.         thistime = BUFSIZE;
  796.       fread (buf, 1, thistime, ifile);
  797.       fwrite (buf, 1, thistime, ofile);
  798.       tocopy -= thistime;
  799.     }
  800.       fclose (ifile);
  801.       if ((sbuf.st_size % 2) == 1)
  802.     putc ('\012', ofile);
  803.     }
  804.   fclose (ofile);
  805.   bfd_close (temp);
  806. }
  807.  
  808.  
  809. static void
  810. write_archive (iarch)
  811.      bfd *iarch;
  812. {
  813.   bfd *obfd;
  814.   int namelen = strlen (bfd_get_filename (iarch));
  815.   char *old_name = xmalloc (namelen + 1);
  816.   char *new_name = xmalloc (namelen + EXT_NAME_LEN);
  817.   bfd *contents_head = iarch->next;
  818.  
  819.   strcpy (old_name, bfd_get_filename (iarch));
  820.   strcpy (new_name, bfd_get_filename (iarch));
  821.  
  822. #ifdef __GO32__            /* avoid long .extensions for MS-DOS */
  823.   strcpy (new_name + namelen, "-a");
  824. #else
  825.   strcpy (new_name + namelen, "-art");
  826. #endif
  827.  
  828.   output_filename = new_name;
  829.  
  830.   obfd = bfd_openw (new_name, bfd_get_target (iarch));
  831.  
  832.   if (obfd == NULL)
  833.     bfd_fatal (old_name);
  834.  
  835.   output_bfd = obfd;
  836.  
  837.   bfd_set_format (obfd, bfd_archive);
  838.  
  839.   /* Request writing the archive symbol table unless we've
  840.      been explicitly requested not to.  */
  841.   obfd->has_armap = write_armap >= 0;
  842.  
  843.   if (bfd_set_archive_head (obfd, contents_head) != true)
  844.     bfd_fatal (old_name);
  845.  
  846.   if (!bfd_close (obfd))
  847.     bfd_fatal (old_name);
  848.  
  849.   output_bfd = NULL;
  850.   output_filename = NULL;
  851.  
  852.   /* We don't care if this fails; we might be creating the archive.  */
  853.   bfd_close (iarch);
  854.   unlink (old_name);
  855.  
  856.   if (rename (new_name, old_name) != 0)
  857.     bfd_fatal (old_name);
  858. }
  859.  
  860. /* Return a pointer to the pointer to the entry which should be rplacd'd
  861.    into when altering.  DEFAULT_POS should be how to interpret pos_default,
  862.    and should be a pos value.  */
  863.  
  864. bfd **
  865. get_pos_bfd (contents, default_pos)
  866.      bfd **contents;
  867.      enum pos default_pos;
  868. {
  869.   bfd **after_bfd = contents;
  870.   enum pos realpos = (postype == pos_default ? default_pos : postype);
  871.  
  872.   if (realpos == pos_end)
  873.     {
  874.       while (*after_bfd)
  875.     after_bfd = &((*after_bfd)->next);
  876.     }
  877.   else
  878.     {
  879.       for (; *after_bfd; after_bfd = &(*after_bfd)->next)
  880.     if (!strcmp ((*after_bfd)->filename, posname))
  881.       {
  882.         if (realpos == pos_after)
  883.           after_bfd = &(*after_bfd)->next;
  884.         break;
  885.       }
  886.     }
  887.   return after_bfd;
  888. }
  889.  
  890. static void
  891. delete_members (arch, files_to_delete)
  892.      bfd *arch;
  893.      char **files_to_delete;
  894. {
  895.   bfd **current_ptr_ptr;
  896.   boolean found;
  897.   boolean something_changed = false;
  898.   for (; *files_to_delete != NULL; ++files_to_delete)
  899.     {
  900.       /* In a.out systems, the armap is optional.  It's also called
  901.      __.SYMDEF.  So if the user asked to delete it, we should remember
  902.      that fact. This isn't quite right for COFF systems (where
  903.      __.SYMDEF might be regular member), but it's very unlikely
  904.      to be a problem.  FIXME */
  905.  
  906.       if (!strcmp (*files_to_delete, "__.SYMDEF"))
  907.     {
  908.       arch->has_armap = false;
  909.       write_armap = -1;
  910.       continue;
  911.     }
  912.  
  913.       found = false;
  914.       current_ptr_ptr = &(arch->next);
  915.       while (*current_ptr_ptr)
  916.     {
  917.       if (strcmp (*files_to_delete, (*current_ptr_ptr)->filename) == 0)
  918.         {
  919.           found = true;
  920.           something_changed = true;
  921.           if (verbose)
  922.         printf ("d - %s\n",
  923.             *files_to_delete);
  924.           *current_ptr_ptr = ((*current_ptr_ptr)->next);
  925.           goto next_file;
  926.         }
  927.       else
  928.         {
  929.           current_ptr_ptr = &((*current_ptr_ptr)->next);
  930.         }
  931.     }
  932.  
  933.       if (verbose && found == false)
  934.     {
  935.       printf ("No member named `%s'\n", *files_to_delete);
  936.     }
  937.     next_file:
  938.       ;
  939.     }
  940.  
  941.   if (something_changed == true)
  942.     {
  943.       write_archive (arch);
  944.     }
  945. }
  946.  
  947.  
  948. /* Reposition existing members within an archive */
  949.  
  950. static void
  951. move_members (arch, files_to_move)
  952.      bfd *arch;
  953.      char **files_to_move;
  954. {
  955.   bfd **after_bfd;        /* New entries go after this one */
  956.   bfd **current_ptr_ptr;    /* cdr pointer into contents */
  957.  
  958.   for (; *files_to_move; ++files_to_move)
  959.     {
  960.       current_ptr_ptr = &(arch->next);
  961.       while (*current_ptr_ptr)
  962.     {
  963.       bfd *current_ptr = *current_ptr_ptr;
  964.       if (strcmp (normalize (*files_to_move), current_ptr->filename) == 0)
  965.         {
  966.           /* Move this file to the end of the list - first cut from
  967.          where it is.  */
  968.           bfd *link;
  969.           *current_ptr_ptr = current_ptr->next;
  970.  
  971.           /* Now glue to end */
  972.           after_bfd = get_pos_bfd (&arch->next, pos_end);
  973.           link = *after_bfd;
  974.           *after_bfd = current_ptr;
  975.           current_ptr->next = link;
  976.  
  977.           if (verbose)
  978.         printf ("m - %s\n", *files_to_move);
  979.  
  980.           goto next_file;
  981.         }
  982.  
  983.       current_ptr_ptr = &((*current_ptr_ptr)->next);
  984.     }
  985.       fprintf (stderr, "%s: no entry %s in archive %s!\n",
  986.            program_name, *files_to_move, arch->filename);
  987.       xexit (1);
  988.     next_file:;
  989.     }
  990.  
  991.   write_archive (arch);
  992. }
  993.  
  994. /* Ought to default to replacing in place, but this is existing practice!  */
  995.  
  996. static void
  997. replace_members (arch, files_to_move)
  998.      bfd *arch;
  999.      char **files_to_move;
  1000. {
  1001.   bfd **after_bfd;        /* New entries go after this one */
  1002.   bfd *current;
  1003.   bfd **current_ptr;
  1004.   bfd *temp;
  1005.  
  1006.   while (files_to_move && *files_to_move)
  1007.     {
  1008.       current_ptr = &arch->next;
  1009.       while (*current_ptr)
  1010.     {
  1011.       current = *current_ptr;
  1012.  
  1013.       if (!strcmp (normalize (*files_to_move), current->filename))
  1014.         {
  1015.           if (newer_only)
  1016.         {
  1017.           struct stat fsbuf, asbuf;
  1018.  
  1019.           if (current->arelt_data == NULL)
  1020.             {
  1021.               /* This can only happen if you specify a file on the
  1022.              command line more than once. */
  1023.               fprintf (stderr,
  1024.                    "%s: duplicate file specified: %s -- skipping\n",
  1025.                    program_name, *files_to_move);
  1026.               goto next_file;
  1027.             }
  1028.  
  1029.           if (stat (*files_to_move, &fsbuf) != 0)
  1030.             {
  1031.               if (errno != ENOENT)
  1032.             bfd_fatal (*files_to_move);
  1033.               goto next_file;
  1034.             }
  1035.           if (bfd_stat_arch_elt (current, &asbuf) != 0)
  1036.             fatal ("internal stat error on %s", current->filename);
  1037.  
  1038.           if (fsbuf.st_mtime <= asbuf.st_mtime)
  1039.             goto next_file;
  1040.         }
  1041.  
  1042.           /* snip out this entry from the chain */
  1043.           *current_ptr = current->next;
  1044.  
  1045.           after_bfd = get_pos_bfd (&arch->next, pos_end);
  1046.           temp = *after_bfd;
  1047.           *after_bfd = bfd_openr (*files_to_move, NULL);
  1048.           if (*after_bfd == (bfd *) NULL)
  1049.         {
  1050.           bfd_fatal (*files_to_move);
  1051.         }
  1052.           (*after_bfd)->next = temp;
  1053.  
  1054.           if (verbose)
  1055.         {
  1056.           printf ("%c - %s\n", (postype == pos_after ? 'r' : 'a'),
  1057.               *files_to_move);
  1058.         }
  1059.           goto next_file;
  1060.         }
  1061.       current_ptr = &(current->next);
  1062.     }
  1063.  
  1064.       /* It isn't in there, so add to end */
  1065.  
  1066.       after_bfd = get_pos_bfd (&arch->next, pos_end);
  1067.       temp = *after_bfd;
  1068.       *after_bfd = bfd_openr (*files_to_move, NULL);
  1069.       if (*after_bfd == (bfd *) NULL)
  1070.     {
  1071.       bfd_fatal (*files_to_move);
  1072.     }
  1073.       if (verbose)
  1074.     {
  1075.       printf ("c - %s\n", *files_to_move);
  1076.     }
  1077.  
  1078.       (*after_bfd)->next = temp;
  1079.  
  1080.     next_file:;
  1081.  
  1082.       files_to_move++;
  1083.     }
  1084.  
  1085.   write_archive (arch);
  1086. }
  1087.  
  1088. static void
  1089. ranlib_only (archname)
  1090.      const char *archname;
  1091. {
  1092.   bfd *arch;
  1093.  
  1094.   write_armap = 1;
  1095.   arch = open_inarch (archname);
  1096.   if (arch == NULL)
  1097.     xexit (1);
  1098.   write_archive (arch);
  1099. }
  1100.  
  1101. /* Update the timestamp of the symbol map of an archive.  */
  1102.  
  1103. static void
  1104. ranlib_touch (archname)
  1105.      const char *archname;
  1106. {
  1107. #ifdef __GO32__
  1108.   /* I don't think updating works on go32.  */
  1109.   ranlib_only (archname);
  1110. #else
  1111.   int f;
  1112.   bfd *arch;
  1113.  
  1114.   f = open (archname, O_RDWR, 0);
  1115.   if (f < 0)
  1116.     {
  1117.       bfd_set_error (bfd_error_system_call);
  1118.       bfd_fatal (archname);
  1119.     }
  1120.  
  1121.   arch = bfd_fdopenr (archname, (const char *) NULL, f);
  1122.   if (arch == NULL
  1123.       || ! bfd_check_format (arch, bfd_archive))
  1124.     bfd_fatal (archname);
  1125.  
  1126.   if (! bfd_has_map (arch))
  1127.     fatal ("%s: no archive map to update", archname);
  1128.  
  1129.   bfd_update_armap_timestamp (arch);
  1130.  
  1131.   if (! bfd_close (arch))
  1132.     bfd_fatal (archname);
  1133. #endif
  1134. }
  1135.  
  1136. /* Things which are interesting to map over all or some of the files: */
  1137.  
  1138. static void
  1139. print_descr (abfd)
  1140.      bfd *abfd;
  1141. {
  1142.   print_arelt_descr (stdout, abfd, verbose);
  1143. }
  1144.